Host the Qwen3.8-Flash CUDA-graph decode loop in the Engine's static path - #2728

…th auxiliary sessions (#2725)

## Description

Adds `session_options.custom_ops_libraries`, a list of custom-op
libraries registered in order after the existing single
`custom_ops_library`, and exports `InheritSessionOptionsFromParent` so
components that create auxiliary sessions (for example MTP/draft heads)
can inherit the decoder's providers, provider options, config entries
and custom ops.

Models whose graphs use several custom-op domains (fused attention,
hyper-connection, GEMM and head ops shipped next to the model package)
currently cannot name more than one library. This change is generic and
has no dependency on any model type; it is the first step of the
Qwen3.8-Flash static-graph backend series (see the end of this
description), but stands alone and targets `main`.

## Summary of Changes

| File | Change |
|------|--------|
| `src/config.h`, `src/config.cpp` | New
`session_options.custom_ops_libraries` (JSON string array; scalar values
such as `"custom_ops_libraries": "ops.so"` are rejected during parsing).
Overlays append to `custom_ops_libraries` (and `[]` leaves existing
entries unchanged). `InheritSessionOptionsFromParent` exposes the
existing inheritance helper; `custom_ops_library` and
`custom_ops_libraries` are inherited together when the child sets
neither (note that `"custom_ops_libraries": []` leaves the vector empty
and therefore still inherits from the parent unless `custom_ops_library`
is set). |
| `src/models/model.cpp` | `custom_ops_library` and then every
`custom_ops_libraries` entry go through the same path-traversal and
allow-list checks, with duplicate resolved paths registered once. All
paths are validated against the allow-list before loading starts;
validated libraries are then loaded and registered sequentially in order
(so a later load/registration error can still leave earlier libraries
registered on `session_options`). |
| `test/CMakeLists.txt`,
`test/cpp/engine/custom_ops_test_lib/custom_ops_test_lib.cpp`,
`test/cpp/engine/custom_ops_libraries_tests.cpp` | Builds two small test
custom-op shared libraries (`custom_ops_test_first` and
`custom_ops_test_second`) and tests parsing/ordering, overlay rules,
rejection of non-string entries and scalar values, inheritance
(including `[]` and `CreateMtpDecoderConfig`), allow-list validation,
and actual library loading, ordering, and deduplication. |

### Library Location Requirement

Every entry in `custom_ops_library` and `custom_ops_libraries` must
resolve to an existing file inside one of the allowed directories:
1. The model folder (alongside `genai_config.json`),
2. A registered Execution Provider (EP) library directory, or
3. The current working directory.

Previously, an unresolved bare library name in `custom_ops_library` was
passed directly to `RegisterCustomOpsLibrary` and could be resolved
through the platform loader search path (`LD_LIBRARY_PATH` / `PATH`).
Unresolved entries are now rejected before loading so the directory
allow-list cannot be bypassed; users should place custom-op libraries in
one of the allowed directories above (typically the model folder).

## Testing

- CPU-only Release build (`-DUSE_CUDA=OFF`) on `main`:
`engine_unit_tests` **929 passed, 0 failed, 2 skipped** (including all 9
tests in `CustomOpsLibrariesConfigTest`, which load real test custom-op
shared libraries to verify registration, ordering, and deduplication).
- `lintrunner`, `clang-format` (20.1.8) and `git diff --check` are
clean.

## Motivation and Context

Found while hosting a model that uses seven custom-op libraries.
Registering them through one `custom_ops_library` entry was not
possible, and auxiliary sessions did not inherit the decoder's custom
ops, so head graphs failed to load without repeating the whole session
configuration.

This is the first PR of a stack that adds an Engine-hosted CUDA-graph
MTP backend for Qwen3.8-Flash-Next (greedy only, one resident request,
Linux/CUDA, no prefix cache). The follow-ups are drafts stacked on
`kvaishnavi/qwen-38-flash-run`, so this commit is also carried as the
first commit of the next PR (#2726) until this one merges. The stack:
#2726 (CUDA data plane library) -> #2727 (model type and device engine)
-> #2728 (Engine hosting) -> #2729 (qualification tools).

## Checklist

- [x] Tests added/updated
- [x] No breaking changes
- [ ] Documentation updated (the option is described in the PR; no
dedicated config documentation exists for `session_options` yet)

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…culative stats

- Propagate unchecked device decode status errors in Qwen38GraphSession::Release() and Begin() (and capture deferred teardown errors) so turns ending via stop strings, cancellation, rewind, or replacement still check device validation bits before Reset().

- Feed the committed RequestStepResult back to Qwen38GraphSession::OnStepCommitted() after Request::CommitExternalTokens so tokens_emitted, tokens_discarded, and accepted/bonus counts reflect actual committed tokens.

- Add unit tests and speculative-stats assertions for EOS, stop-string, and canceled turns.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…culative stats

- Propagate unchecked device decode status errors in Qwen38GraphSession::Release() and Begin() (and capture deferred teardown errors) so turns ending via stop strings, cancellation, rewind, or replacement still check device validation bits before Reset().

- Feed the committed RequestStepResult back to Qwen38GraphSession::OnStepCommitted() after Request::CommitExternalTokens so tokens_emitted, tokens_discarded, and accepted/bonus counts reflect actual committed tokens.

- Add unit tests and speculative-stats assertions for EOS, stop-string, and canceled turns.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…culative stats

- Propagate unchecked device decode status errors in Qwen38GraphSession::Release() and Begin() (and capture deferred teardown errors) so turns ending via stop strings, cancellation, rewind, or replacement still check device validation bits before Reset().

- Feed the committed RequestStepResult back to Qwen38GraphSession::OnStepCommitted() after Request::CommitExternalTokens so tokens_emitted, tokens_discarded, and accepted/bonus counts reflect actual committed tokens.

- Add unit tests and speculative-stats assertions for EOS, stop-string, and canceled turns.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…culative stats

- Propagate unchecked device decode status errors in Qwen38GraphSession::Release() and Begin() (and capture deferred teardown errors) so turns ending via stop strings, cancellation, rewind, or replacement still check device validation bits before Reset().

- Feed the committed RequestStepResult back to Qwen38GraphSession::OnStepCommitted() after Request::CommitExternalTokens so tokens_emitted, tokens_discarded, and accepted/bonus counts reflect actual committed tokens.

- Add unit tests and speculative-stats assertions for EOS, stop-string, and canceled turns.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

The wasted look-ahead cycle of a stop-string or canceled turn is never
waited for, so its record stays unconsumed and only the device status bits
can tell that it failed. The production device keeps that record after
Drain() and, since #2727, CheckDecodeStatus() reads the accumulated bits
also then; the Reset() that follows clears them.

The executor already drains and checks the status before every Reset()
(Begin, Release, end of turn). The scripted device now behaves like the
production one so that this is actually exercised: Drain() completes the
running cycle but leaves its record in flight, the cycle can accumulate
error bits (fail_cycle), CheckDecodeStatus() reads them with a cycle in
flight or unconsumed, and the device logs the drain/status/reset order.

New tests: a failing look-ahead cycle of a stop-string turn surfaces when
the turn is rewound and fails the next request instead of being reset
away; the same for a canceled turn; a clean drained cycle lets the next
request run. Document the Drain() + CheckDecodeStatus() contract.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

A cycle that the Engine ends inside its accepted prefix (turn or session
limit, stop string, EOS) was reported with min(proposed, accepted + 1)
evaluated drafts. With three accepted drafts but room for one token that
is two evaluated drafts for one accepted one, a 50% acceptance rate where
Engine::RecordSpeculativeCommit reports 100%.

Count the draft positions the turn examined up to its terminal token, like
Request::CommitAcceptedDraftsForTransaction does: every accepted draft it
consumed (an EOS draft is examined but not accepted) plus the rejected
position only when the turn reached the correction token.

The scripted device gains multi-draft cycles (SetDrafts: 1..3 drafts per
verify, any accepted prefix, reported through accepted_count/proposed_count
like the production device). Tests cover limit, session limit, stop string
and EOS truncation inside the accepted prefix, on the correction token and
on the bonus token; five of them fail with the old formula.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

A round that accepted some but not all of its drafts only recorded its
histogram entry: the zero/full classification skipped it and
partial_accept_rounds was never incremented, nor merged by AddStats.

Classify every round like Engine::RecordSpeculativeCommit does, by the
number of accepted drafts that were delivered (none: zero, all of the
proposed ones: full, otherwise partial), independently of whether a
correction token followed, and merge partial_accept_rounds in AddStats.
Bonus and correction tokens keep being counted on their own.

Tests cover a 0/1/2/3 accepted sequence of three-draft rounds (counters,
histogram, correction/bonus, acceptance rate), a partial round whose
correction does not fit the turn, a round truncated inside its accepted
drafts, an EOS first draft (zero accept) and the sum over requests.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…l total

The executor hands the prompt length of a turn to its own device
(ExpectPrefillTokens, after Reset() and before the first chunk) and never
publishes it through the process environment. Pin that with a scripted-device
test: two Engines on two owner threads, each with its own model and device, are
held at a rendezvous between the publication of the length and the first chunk
of every turn, and each device must keep its own total across the chunks of a
new turn, a continued turn that re-ingests the history after a Reset, and a
canceled turn, while ORT_QMOE_PREFILL_TOTAL_TOKENS stays untouched.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…capability clamping, and prompt validation

- Use FixedSlotScheduler in CreateQwen38GraphDependencies and Scheduler::Create for continuous multi-slot caches, and require scheduler.SupportsIndependentSlotAdmission() for BackendAdmission::IndependentSlots.
- Clamp resolved and declared static max_request_length to model.context_length as well as cache capacity.
- Validate prompt token IDs against model.vocab_size at turn admission (and in Qwen38GraphSession::Begin) before mutating Request or device state.
- Ensure restartable canceled and rewound nonresident requests remain enrolled in StaticBatchScheduler and FixedSlotScheduler without duplicates.
- Use span.h in qwen38_graph_test_doubles.h and clarify scoped Qwen38OrtEnvScope publication in docs/paged_attention_engine.md.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>